package org.example;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * Hello world!
 *
 */
public class App 
{


    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1,                      // 核心线程数
                2,                      // 最大线程数
                60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1)  // 队列容量1
        );

        // 提交3个任务：1个线程 + 队列容量1 + 1个临时线程
        executor.execute(() -> {System.out.println("Task 1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });  // 核心线程执行
        executor.execute(() -> {System.out.println("Task 2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });  // 放入队列
        executor.execute(() -> {System.out.println("Task 3");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });  // 创建临时线程


        // 此时线程池已满（2个线程），队列也已满（容量1）
        System.out.println("线程池大小: " + executor.getPoolSize());        // 2
        System.out.println("队列大小: " + executor.getQueue().size());      // 1

        // 提交第4个任务：触发拒绝策略
        try {
            executor.execute(() -> System.out.println("Task 4"));
        } catch (RejectedExecutionException e) {
            System.err.println("拒绝策略触发: " + e.getMessage());
        }

        executor.shutdown();
    }
    public static void main2( String[] args )
    {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5,                     // 核心线程数
                10,                    // 最大线程数
                60,                    // 空闲线程存活时间
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(100),  // 有界队列
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
        );



        // 提交一个简单的 Runnable 任务,没返回值--------------------------------------------------------
        executor.execute(() -> {
            System.out.println("任务执行: " + Thread.currentThread().getName());
        });


        // 提交一个 Callable 任务并获取 Future,有返回值-------------------------------------------
        Future<String> future = executor.submit(() -> {
            Thread.sleep(1000);
            return "任务完成";
        });

        // 获取任务结果（阻塞方法）
        try {
            String result = future.get();  // 阻塞直到任务完成
            System.out.println("任务结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }


        // 优雅关闭：不再接受新任务，但会执行完已提交的任务
        executor.shutdown();

// 强制关闭：尝试停止所有正在执行的任务，返回未执行的任务列表
        List<Runnable> pendingTasks = executor.shutdownNow();




       // 使用 invokeAll 批量提交任务
// 创建任务列表
        List<Callable<Integer>> tasks = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            tasks.add(() -> {
                Thread.sleep(500);
                return taskId * 2;
            });
        }

// 批量提交任务并等待所有任务完成
//        try {
//            List<Future<Integer>> futures = executor.invokeAll(tasks);
//
//            // 处理结果
//            for (Future<Integer> future : futures) {
//                System.out.println("结果: " + future.get());
//            }
//        } catch (InterruptedException | ExecutionException e) {
//            e.printStackTrace();
//        }




//        使用 CompletionService 处理异步结果
        // 创建 CompletionService 包装线程池
        CompletionService<Integer> completionService = new ExecutorCompletionService<>(executor);

// 提交多个任务
//        for (int i = 0; i < 5; i++) {
//            final int taskId = i;
//            completionService.submit(() -> {
//                Thread.sleep(1000 - taskId * 100); // 任务执行时间不同
//                return taskId;
//            });
//        }
//
//// 按完成顺序获取结果
//        for (int i = 0; i < 5; i++) {
//            try {
//                Future<Integer> future = completionService.take(); // 阻塞直到有任务完成
//                System.out.println("完成任务: " + future.get());
//            } catch (InterruptedException | ExecutionException e) {
//                e.printStackTrace();
//            }
//        }



        // 监控线程池状态
        System.out.println("活跃线程数: " + executor.getActiveCount());
        System.out.println("队列任务数: " + executor.getQueue().size());
        System.out.println("已完成任务数: " + executor.getCompletedTaskCount());
        System.out.println("线程池是否关闭: " + executor.isShutdown());
    }


    public static void main1(String[] args) {
        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                3,  // 核心线程数
                5,  // 最大线程数
                30, // 空闲时间
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10) // 任务队列
        );

        // 模拟提交10个任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                try {
                    System.out.println("任务 " + taskId + " 由线程 " + Thread.currentThread().getName() + " 执行");
                    Thread.sleep(2000); // 模拟任务执行时间
                    System.out.println("任务 " + taskId + " 完成");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        executor.shutdown();

        // 等待所有任务完成
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }

}
